package com.miage.itrading.entites;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import com.miage.itrading.utils.Util;

/**
 * The persistent class for the cotation database table.
 * 
 */
public class Cotation implements Serializable {
	private static final long	serialVersionUID	= 1L;
	private int					idCotation;
	private String				mnemonique;
	private String				mnemonique2;
	private String				nom;
	
	/**
	 * Les données sont entrées par date croissante (de la plus ancienne à la plus récente)  
	 */
	private List<Historique>	historiques;
	private List<Intraday>		intradays;
	
	public Cotation() {
		historiques = new ArrayList<Historique>();
		intradays   = new ArrayList<Intraday>();
	}
	
	/**
	 * Merge les historiques de la cotation avec les nouveaux historiques
	 * 
	 * @param histo Liste des historique à ajouter à la cotation
	 */
	public void mergeHistorique(List<Historique> histo) {
		ArrayList<Historique> histoTrie = new ArrayList<Historique>();
		
		if (histo.size() != 0)  {
			histoTrie.add(histo.get(0));
			
			for (int i=1 ; i<histo.size() ; ++i) {
				for (int j=0 ; j<histoTrie.size() ; ++j) {
					if (histo.get(i).getDate().after(histoTrie.get(j).getDate())) {
						histoTrie.add(j, histo.get(i));
						break;
					}
				}
			}
		
			if (historiques.size() == 0) {
				historiques = histoTrie;
			}
			else {
				for (int i=0 ; i<histoTrie.size() ; ++i) {
					for (int j=0 ; j<historiques.size() ; ++j) {
						if (histoTrie.get(i).getDate().after(historiques.get(j).getDate())) {
							historiques.add(j, histoTrie.get(i));
							break;
						}
					}
				}
			}
		}
	}

	
	public void mergeHistorique(Historique histo) {
		/**
		 * On vérifie d'abord si la valeur à ajouter n'est pas plus récente que celles présentes,
		 * cela sera généralement le cas, du fait de l'actualisation des cours
		 */
		if (historiques.size() == 0) {
			historiques.add(histo);
		}
//		else if (histo.getDate().after(historiques.get(historiques.size() - 1 ).getDate())) {
//			historiques.add(histo);
//		}
		else {		
			for (int i=0 ; i<historiques.size() ; ++i) {
				if (historiques.get(i).getDate().after(histo.getDate())) {
					historiques.add(i, histo);
					break;
				}	
			}
		}
	}


	public void mergeIntraday(List<Intraday> intra) {
		
		if (intra != null) {
			/**
			 * Sorts the input list
			 */
			ArrayList<Intraday> intraTrie = new ArrayList<Intraday>();
			
			if (intra.size() != 0)  {
				intraTrie.add(intra.get(0));
				
				for (int i=1 ; i<intra.size() ; ++i) {
					for (int j=0 ; j<intraTrie.size() ; ++j) {
						if (intra.get(i).getDate().after(intraTrie.get(j).getDate())) {
							intraTrie.add(j, intra.get(i));
							break;
						}
					}
				}
			
				if (intradays.size() == 0) {
					intradays = intraTrie;
				}
				else {
					for (int i=0 ; i<intraTrie.size() ; ++i) {
						for (int j=0 ; j<intradays.size() ; ++j) {
							if (intraTrie.get(i).getDate().after(intradays.get(j).getDate())) {
								intradays.add(j, intraTrie.get(i));
								break;
							}
						}
					}
				}
			}			
		}
	}
	
	public void mergeIntraday(Intraday intra) {
		if (intra != null) {
			
			intradays.add(intra);
			
//			if (intradays.size() == 0) {
//				intradays.add(intra);
//			}
//			else {
//				for (int i=intradays.size() - 1 ; i>=0 ; --i) {
//					if (intra.getDate().after(intradays.get(i).getDate())) {
//						intradays.add(i, intra);
//						break;
//					}
//				}
//			}
		}
	}
	

	
	public float getValeurClotureVeille() {
		if (historiques.size() != 0) {
			return historiques.get(historiques.size() - 1).getFermeture();
		} else {
			return 0;
		}
	}
	
	/**
	 * 
	 * @return la dernière valeur de la cotation
	 */
	public float getLastValeur() {
		float valeur = 0f;
		
		if (historiques.size() > 0 && intradays.size() > 0) {
			Intraday dernierIntraday		= intradays.get(intradays.size() - 1);
			Historique dernierHistorique	= historiques.get(historiques.size() - 1);
			
			Date dateHistorique	= Util.getDateBySQL(dernierHistorique.getDate());
			Date dateIntraday	= dernierIntraday.getDate();
			
			
			if (dateHistorique == null && dateIntraday == null) {
				System.out.println("les deux sont null pour " + getNom());
				
				return valeur;
			}
			else if (dateIntraday == null) {
				
				System.out.println("dateItnraday null pour " + getNom());
				
				return dernierHistorique.getFermeture();
			}
			else if (dateHistorique == null) {
				System.out.println("historique null pour " + getNom());
				
				return dernierIntraday.getCotation();
			}
		}
		else if (historiques.size() > 0) {
			System.out.println("que l'historique pour " + getNom());
			
			valeur = historiques.get(historiques.size() - 1).getFermeture();
		}
		else if (intradays.size() > 0) {
			System.out.println("que l'intraday pour " + getNom());
			
			valeur = intradays.get(intradays.size() - 1).getCotation();
		}
		else {
			System.out.println("au bois! pour " + getNom());
		}
			
		return valeur;
	}
	
	public List<Intraday> getIntradays() {
		return this.intradays;
	}
	
	public void setIntradays(List<Intraday> i) {
		this.intradays = i;
	}

	public List<Historique> getHistoriques() {
		return this.historiques;
	}

	public int getIdCotation() {
		return this.idCotation;
	}

	public String getMnemonique() {
		return this.mnemonique;
	}

	public String getNom() {
		return this.nom;
	}

	public void setHistoriques(List<Historique> historiques) {
		this.historiques = historiques;
	}

	public void setIdCotation(int idCotation) {
		this.idCotation = idCotation;
	}

	public void setMnemonique(String mnemonique) {
		this.mnemonique = mnemonique;
	}

	public void setNom(String nom) {
		this.nom = nom;
	}

	public String getMnemonique2() {
		return mnemonique2;
	}

	public void setMnemonique2(String mnemonique2) {
		this.mnemonique2 = mnemonique2;
	}
	
	public boolean equals(Object o) {
		  if (this == o)
			  return true;
		  
		  if (!(o instanceof Cotation))
			  return false;
		  
		  Cotation c = (Cotation) o;
		  
		  return c.getNom().equals(getNom());
	}
}